{
 "cells": [
  {
   "cell_type": "code",
   "id": "initial_id",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2025-03-06T07:58:52.378604Z",
     "start_time": "2025-03-06T07:58:52.371532Z"
    }
   },
   "source": [
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import sklearn\n",
    "import pandas as pd\n",
    "import os\n",
    "import sys\n",
    "import time\n",
    "from tqdm.auto import tqdm\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "print(sys.version_info)\n",
    "for module in mpl, np, pd, sklearn, torch:\n",
    "    print(module.__name__, module.__version__)\n",
    "\n",
    "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "print(device)\n",
    "\n",
    "seed = 42\n",
    "torch.manual_seed(seed)\n",
    "torch.cuda.manual_seed_all(seed)\n"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sys.version_info(major=3, minor=12, micro=3, releaselevel='final', serial=0)\n",
      "matplotlib 3.10.0\n",
      "numpy 1.26.4\n",
      "pandas 2.2.3\n",
      "sklearn 1.6.0\n",
      "torch 2.3.1+cu121\n",
      "cuda:0\n"
     ]
    }
   ],
   "execution_count": 35
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 数据准备",
   "id": "42a2ff37b45e01b"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T07:58:54.511314Z",
     "start_time": "2025-03-06T07:58:52.477984Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from tensorflow import keras\n",
    "\n",
    "# karas中的数据集imbd，电影评论分类\n",
    "imdb = keras.datasets.imdb\n",
    "\n",
    "# 载入数据\n",
    "# 词典大小，仅保留训练数据中前10000个最经常出现的单词，低频单词被舍弃\n",
    "vocab_size = 10000\n",
    "\n",
    "# 序号从3开始，0,1,2,3空出来做别的事,作为特殊字符处理\n",
    "index_from = 3\n",
    "\n",
    "# 取出的词表是从1开始的，需要做处理\n",
    "(train_data, train_labels), (test_data, test_labels) = imdb.load_data(\n",
    "    num_words=vocab_size, index_from=index_from)"
   ],
   "id": "496ef1cb9cb78513",
   "outputs": [],
   "execution_count": 36
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T07:58:54.516904Z",
     "start_time": "2025-03-06T07:58:54.512473Z"
    }
   },
   "cell_type": "code",
   "source": [
    "print(\"tpye of train_data:\", type(train_data))\n",
    "print(\"shape of train_data:\", train_data.shape)  # #每个样本是一段话，每个单词用一个数字表示\n",
    "print(\"type of train_labels:\", type(train_labels))\n",
    "print(\"shape of train_labels:\", train_labels.shape)"
   ],
   "id": "93817635d8071f78",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tpye of train_data: <class 'numpy.ndarray'>\n",
      "shape of train_data: (25000,)\n",
      "type of train_labels: <class 'numpy.ndarray'>\n",
      "shape of train_labels: (25000,)\n"
     ]
    }
   ],
   "execution_count": 37
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T07:58:54.551251Z",
     "start_time": "2025-03-06T07:58:54.516904Z"
    }
   },
   "cell_type": "code",
   "source": [
    "#载入词表，看下词表长度，词表就像英语字典\n",
    "# 加载IMDB词典，将其转换为字典形式\n",
    "word_index = imdb.get_word_index()\n",
    "print(len(word_index))\n",
    "print(type(word_index))\n",
    "# 词表有八万多单词，只加载前10000个单词"
   ],
   "id": "a966628d248b162e",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "88584\n",
      "<class 'dict'>\n"
     ]
    }
   ],
   "execution_count": 38
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 构造 word2idx 和 idx2word",
   "id": "b7f4fd1b78d731f4"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T07:58:54.568841Z",
     "start_time": "2025-03-06T07:58:54.552405Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 词典，单词到id的映射，作用：将文本转换为数字序列\n",
    "word2idx = {word: (idx + 3) for word, idx in word_index.items()}\n",
    "word2idx.update({\n",
    "    \"[PAD]\": 0,  # 填充token\n",
    "    \"[BOS]\": 1,  # 句子开始\n",
    "    \"[UNK]\": 2,  # 未知token\n",
    "    \"[EOS]\": 3,  # 句子结束\n",
    "})\n",
    "\n",
    "# 反向词典，id变为单词，作用：将模型输出的id转换为单词\n",
    "idx2word = {idx: word for word, idx in word2idx.items()}"
   ],
   "id": "a092d7101f890bb7",
   "outputs": [],
   "execution_count": 39
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T07:58:55.186921Z",
     "start_time": "2025-03-06T07:58:54.569855Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 构造句子长度统计图\n",
    "length_collect = {}\n",
    "#统计样本中每个长度出现的次数\n",
    "for text in train_data:\n",
    "    # 单个句子的长度\n",
    "    length = len(text)\n",
    "\n",
    "    # 统计长度的频率\n",
    "    length_collect[length] = length_collect.get(length, 0) + 1\n",
    "\n",
    "MAX_LENGTH = 500\n",
    "# 长度分布图\n",
    "plt.bar(length_collect.keys(), length_collect.values())\n",
    "plt.axvline(MAX_LENGTH, label=\"max length\", c=\"gray\", ls=\":\")\n",
    "plt.legend()\n",
    "plt.show()"
   ],
   "id": "3bc2b8c01f275daa",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 40
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# Tokenizer",
   "id": "d51e77136a24d294"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T07:58:55.197588Z",
     "start_time": "2025-03-06T07:58:55.186921Z"
    }
   },
   "cell_type": "code",
   "source": [
    "class Tokenizer:\n",
    "\n",
    "    def __init__(self, word2idx, idx2word, max_length=500, pad_idx=0, bos_idx=1, eos_idx=3, unk_idx=2):\n",
    "        self.word2idx = word2idx  #词表,单词到id\n",
    "        self.idx2word = idx2word  #词表，id到单词\n",
    "        self.max_length = max_length\n",
    "        self.pad_idx = pad_idx  #填充\n",
    "        self.bos_idx = bos_idx  #开始\n",
    "        self.eos_idx = eos_idx  #结束\n",
    "        self.unk_idx = unk_idx  #未知，未出现在最高频词表中的词\n",
    "\n",
    "    def encode(self, text_list, padding_first=False):\n",
    "        \"\"\"\n",
    "        将文本列表转化为索引列表\n",
    "        :param text_list:当前批次的文本列表\n",
    "        :param padding_first:是否padding加载前面\n",
    "        :return:\n",
    "        \"\"\"\n",
    "        # 最大长度，句子长度小于500，取句子长度，大于500，取500，一个批次内的最大长度\n",
    "        max_length = min(self.max_length, 2 + max([len(text) for text in text_list]))\n",
    "        indices_list = []\n",
    "        for text in text_list:\n",
    "\n",
    "            #直接切片取前max_length-2个单词，然后加上bos和eos\n",
    "            indices = [self.bos_idx] + [self.word2idx.get(word, self.unk_idx) for word in text[:max_length - 2]] + [\n",
    "                self.eos_idx]\n",
    "            if padding_first:\n",
    "                # 填充0\n",
    "                indices = [self.pad_idx] * (max_length - len(indices)) + indices\n",
    "            else:\n",
    "                # 如果padding_first == False，则padding加载后面\n",
    "                indices = indices + [self.pad_idx] * (max_length - len(indices))\n",
    "            indices_list.append(indices)\n",
    "        return torch.tensor(indices_list)  #二维列表转化为tensor\n",
    "\n",
    "    def decode(self, indices_list, remove_bos=True, remove_eos=True, remove_pad=True, split=False):\n",
    "        \"\"\"\n",
    "        将索引列表转化为文本列表\n",
    "        :param indices_list:某批次的索引列表\n",
    "        :param remove_bos:移除开始符\n",
    "        :param remove_eos:移除结束符\n",
    "        :param remove_pad:移除填充符\n",
    "        :param split:分词\n",
    "        :return:\n",
    "        \"\"\"\n",
    "        # 生成文本列表\n",
    "        text_list = []\n",
    "        for indices in indices_list:\n",
    "            # 单词列表\n",
    "            text = []\n",
    "\n",
    "            # 循环遍历索引列表\n",
    "            for index in indices:\n",
    "\n",
    "                # id转化为单词\n",
    "                word = self.idx2word.get(index, \"[UNK]\")\n",
    "                # 移除开始符\n",
    "                if remove_bos and word == \"[BOS]\":\n",
    "                    continue\n",
    "                # 移除结束符\n",
    "                if remove_eos and word == \"[EOS]\":\n",
    "                    break\n",
    "                # 移除填充符\n",
    "                if remove_pad and word == \"[PAD]\":\n",
    "                    break\n",
    "                # 添加单词到文本列表\n",
    "                text.append(word)\n",
    "            # 合并单词列表为句子\n",
    "            text_list.append(\" \".join(text) if not split else text)\n",
    "        return text_list\n",
    "\n",
    "\n",
    "# 实例化Tokenizer\n",
    "tokenizer = Tokenizer(word2idx=word2idx, idx2word=idx2word)"
   ],
   "id": "47a2971d2e84f341",
   "outputs": [],
   "execution_count": 41
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 数据集与 DataLoader",
   "id": "bc5a1fbde4c74520"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T07:58:55.989633Z",
     "start_time": "2025-03-06T07:58:55.197588Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from torch.utils.data import Dataset, DataLoader\n",
    "\n",
    "\n",
    "class IMDBDataset(Dataset):\n",
    "    def __init__(self, data, labels, remain_length=True):\n",
    "        if remain_length:  #字符串输出样本中，是否含有【BOS】和【EOS】，【PAD】\n",
    "            self.data = tokenizer.decode(data, remove_bos=False, remove_eos=False, remove_pad=False)\n",
    "        else:\n",
    "            # 去除【BOS】和【EOS】，【PAD】\n",
    "            self.data = tokenizer.decode(data)\n",
    "        self.labels = labels\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        text = self.data[index]\n",
    "        label = self.labels[index]\n",
    "        return text, label\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.data)\n",
    "\n",
    "\n",
    "def collate_fct(batch):\n",
    "    \"\"\"\n",
    "    将batch数据处理成tensor形式\n",
    "    :param batch:\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    # 文本列表，批次中每个样本的文本分词[[],[],[]]\n",
    "    text_list = [item[0].split() for item in batch]\n",
    "    # 标签列表\n",
    "    label_list = [item[1] for item in batch]\n",
    "    # 文本列表转化为索引列表\n",
    "    # 使用padding_first=True\n",
    "    text_list = tokenizer.encode(text_list, padding_first=True).to(dtype=torch.int)\n",
    "\n",
    "    # 标签列表转化为tensor,reshape(-1,1)是为了适配线性层的输入\n",
    "    return text_list, torch.tensor(label_list).reshape(-1, 1).to(dtype=torch.float)\n",
    "\n",
    "\n",
    "train_ds = IMDBDataset(train_data, train_labels)\n",
    "test_ds = IMDBDataset(test_data, test_labels)"
   ],
   "id": "258717916af529fd",
   "outputs": [],
   "execution_count": 42
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "",
   "id": "6306107bd5287ef8"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T07:58:55.995688Z",
     "start_time": "2025-03-06T07:58:55.989633Z"
    }
   },
   "cell_type": "code",
   "source": [
    "batch_size = 128\n",
    "train_dl = DataLoader(train_ds, batch_size=batch_size, shuffle=True, collate_fn=collate_fct)  #collate_fn是处理batch的函数\n",
    "test_dl = DataLoader(test_ds, batch_size=batch_size, shuffle=False, collate_fn=collate_fct)"
   ],
   "id": "436fe2610309bc4d",
   "outputs": [],
   "execution_count": 43
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 模型定义",
   "id": "ed515dab0993382f"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T07:58:56.002233Z",
     "start_time": "2025-03-06T07:58:55.995688Z"
    }
   },
   "cell_type": "code",
   "source": [
    "class LSTM(nn.Module):\n",
    "    def __init__(self, embedding_dim=16, hidden_dim=64, vocab_size=vocab_size, num_layers=1, bidirectional=False):\n",
    "        super(LSTM, self).__init__()\n",
    "        # 词嵌入层\n",
    "        self.embeding = nn.Embedding(vocab_size, embedding_dim)\n",
    "        # LSTM层\n",
    "        self.lstm = nn.LSTM(embedding_dim, hidden_dim, num_layers=num_layers, batch_first=True,\n",
    "                            bidirectional=bidirectional)\n",
    "        # 全连接层\n",
    "        self.layer = nn.Linear(hidden_dim * (2 if bidirectional else 1), hidden_dim)\n",
    "        # 输出层\n",
    "        self.fc = nn.Linear(hidden_dim, 1)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.embeding(x)  # [bs, seq length]->[bs, seq length, embedding_dim]\n",
    "        seq_output, (hidden, cell) = self.lstm(x)  #   [bs, seq length, hidden_dim]\n",
    "        x = seq_output[:, -1, :]  # 取最后一个时间步的输出 (这也是为什么要设置padding_first=True的原因)\n",
    "        x = self.layer(x)\n",
    "        x = self.fc(x)\n",
    "        return x\n",
    "\n",
    "\n",
    "print(\"{:=^80}\".format(\" 一层单向 LSTM \"))\n",
    "for key, value in LSTM().named_parameters():\n",
    "    print(f\"{key:^40}paramerters num: {np.prod(value.shape)}\")"
   ],
   "id": "95f297c3e18d73f8",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "================================== 一层单向 LSTM ===================================\n",
      "            embeding.weight             paramerters num: 160000\n",
      "           lstm.weight_ih_l0            paramerters num: 4096\n",
      "           lstm.weight_hh_l0            paramerters num: 16384\n",
      "            lstm.bias_ih_l0             paramerters num: 256\n",
      "            lstm.bias_hh_l0             paramerters num: 256\n",
      "              layer.weight              paramerters num: 4096\n",
      "               layer.bias               paramerters num: 64\n",
      "               fc.weight                paramerters num: 64\n",
      "                fc.bias                 paramerters num: 1\n"
     ]
    }
   ],
   "execution_count": 44
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T07:58:56.196618Z",
     "start_time": "2025-03-06T07:58:56.003757Z"
    }
   },
   "cell_type": "code",
   "source": [
    "model = LSTM()\n",
    "#随机一个（128,500）的输入\n",
    "sample_inputs = torch.randint(0, vocab_size, (128, 500))\n",
    "sample_outputs = model(sample_inputs)\n",
    "print(sample_outputs.shape)"
   ],
   "id": "b5603855d8461942",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([128, 1])\n"
     ]
    }
   ],
   "execution_count": 45
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T07:58:56.204923Z",
     "start_time": "2025-03-06T07:58:56.197622Z"
    }
   },
   "cell_type": "code",
   "source": [
    "print(\"{:=^80}\".format(\" 一层双向 LSTM \"))\n",
    "for key, value in LSTM(bidirectional=True).named_parameters():\n",
    "    print(f\"{key:^40}paramerters num: {np.prod(value.shape)}\")"
   ],
   "id": "32782fed5d484e24",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "================================== 一层双向 LSTM ===================================\n",
      "            embeding.weight             paramerters num: 160000\n",
      "           lstm.weight_ih_l0            paramerters num: 4096\n",
      "           lstm.weight_hh_l0            paramerters num: 16384\n",
      "            lstm.bias_ih_l0             paramerters num: 256\n",
      "            lstm.bias_hh_l0             paramerters num: 256\n",
      "       lstm.weight_ih_l0_reverse        paramerters num: 4096\n",
      "       lstm.weight_hh_l0_reverse        paramerters num: 16384\n",
      "        lstm.bias_ih_l0_reverse         paramerters num: 256\n",
      "        lstm.bias_hh_l0_reverse         paramerters num: 256\n",
      "              layer.weight              paramerters num: 8192\n",
      "               layer.bias               paramerters num: 64\n",
      "               fc.weight                paramerters num: 64\n",
      "                fc.bias                 paramerters num: 1\n"
     ]
    }
   ],
   "execution_count": 46
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T07:58:56.211699Z",
     "start_time": "2025-03-06T07:58:56.205927Z"
    }
   },
   "cell_type": "code",
   "source": [
    "print(\"{:=^80}\".format(\" 两层单向 LSTM \"))\n",
    "for key, value in LSTM(num_layers=2).named_parameters():\n",
    "    print(f\"{key:^40}paramerters num: {np.prod(value.shape)}\")"
   ],
   "id": "ae10462f3fd7c3cc",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "================================== 两层单向 LSTM ===================================\n",
      "            embeding.weight             paramerters num: 160000\n",
      "           lstm.weight_ih_l0            paramerters num: 4096\n",
      "           lstm.weight_hh_l0            paramerters num: 16384\n",
      "            lstm.bias_ih_l0             paramerters num: 256\n",
      "            lstm.bias_hh_l0             paramerters num: 256\n",
      "           lstm.weight_ih_l1            paramerters num: 16384\n",
      "           lstm.weight_hh_l1            paramerters num: 16384\n",
      "            lstm.bias_ih_l1             paramerters num: 256\n",
      "            lstm.bias_hh_l1             paramerters num: 256\n",
      "              layer.weight              paramerters num: 4096\n",
      "               layer.bias               paramerters num: 64\n",
      "               fc.weight                paramerters num: 64\n",
      "                fc.bias                 paramerters num: 1\n"
     ]
    }
   ],
   "execution_count": 47
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 模型训练",
   "id": "3db29cf953cdbc9b"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T07:58:56.217703Z",
     "start_time": "2025-03-06T07:58:56.211699Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "\n",
    "@torch.no_grad()\n",
    "def evaluating(model, dataloader, loss_fct):\n",
    "    loss_list = []\n",
    "    pred_list = []\n",
    "    label_list = []\n",
    "    for datas, labels in dataloader:\n",
    "        datas = datas.to(device)\n",
    "        labels = labels.to(device)\n",
    "        # 前向计算\n",
    "        logits = model(datas)\n",
    "        loss = loss_fct(logits, labels)  # 验证集损失\n",
    "        loss_list.append(loss.item())\n",
    "        # 二分类\n",
    "        preds = logits > 0\n",
    "        pred_list.extend(preds.cpu().numpy().tolist())\n",
    "        label_list.extend(labels.cpu().numpy().tolist())\n",
    "\n",
    "    acc = accuracy_score(label_list, pred_list)\n",
    "    return np.mean(loss_list), acc\n"
   ],
   "id": "24169a65e81682f8",
   "outputs": [],
   "execution_count": 48
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T07:58:56.224568Z",
     "start_time": "2025-03-06T07:58:56.218798Z"
    }
   },
   "cell_type": "code",
   "source": [
    "class SaveCheckpointsCallback:\n",
    "    def __init__(self, save_dir, save_step=5000, save_best_only=True):\n",
    "        \"\"\"\n",
    "        Save checkpoints each save_epoch epoch. \n",
    "        We save checkpoint by epoch in this implementation.\n",
    "        Usually, training scripts with pytorch evaluating model and save checkpoint by step.\n",
    "\n",
    "        Args:\n",
    "            save_dir (str): dir to save checkpoint\n",
    "            save_epoch (int, optional): the frequency to save checkpoint. Defaults to 1.\n",
    "            save_best_only (bool, optional): If True, only save the best model or save each model at every epoch.\n",
    "        \"\"\"\n",
    "        self.save_dir = save_dir\n",
    "        self.save_step = save_step\n",
    "        self.save_best_only = save_best_only\n",
    "        self.best_metrics = -1\n",
    "\n",
    "        # mkdir\n",
    "        if not os.path.exists(self.save_dir):\n",
    "            os.mkdir(self.save_dir)\n",
    "\n",
    "    def __call__(self, step, state_dict, metric=None):\n",
    "        if step % self.save_step > 0:\n",
    "            return\n",
    "\n",
    "        if self.save_best_only:\n",
    "            assert metric is not None\n",
    "            if metric >= self.best_metrics:\n",
    "                # save checkpoints\n",
    "                torch.save(state_dict, os.path.join(self.save_dir, \"best.ckpt\"))\n",
    "                # update best metrics\n",
    "                self.best_metrics = metric\n",
    "        else:\n",
    "            torch.save(state_dict, os.path.join(self.save_dir, f\"{step}.ckpt\"))\n",
    "\n"
   ],
   "id": "175b3e1e9e64870b",
   "outputs": [],
   "execution_count": 49
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T07:58:56.230586Z",
     "start_time": "2025-03-06T07:58:56.225576Z"
    }
   },
   "cell_type": "code",
   "source": [
    "class EarlyStopCallback:\n",
    "    def __init__(self, patience=5, min_delta=0.01):\n",
    "        \"\"\"\n",
    "\n",
    "        Args:\n",
    "            patience (int, optional): Number of epochs with no improvement after which training will be stopped.. Defaults to 5.\n",
    "            min_delta (float, optional): Minimum change in the monitored quantity to qualify as an improvement, i.e. an absolute \n",
    "                change of less than min_delta, will count as no improvement. Defaults to 0.01.\n",
    "        \"\"\"\n",
    "        self.patience = patience\n",
    "        self.min_delta = min_delta\n",
    "        self.best_metric = -1\n",
    "        self.counter = 0\n",
    "\n",
    "    def __call__(self, metric):\n",
    "        if metric >= self.best_metric + self.min_delta:\n",
    "            # update best metric\n",
    "            self.best_metric = metric\n",
    "            # reset counter \n",
    "            self.counter = 0\n",
    "        else:\n",
    "            self.counter += 1\n",
    "\n",
    "    @property\n",
    "    def early_stop(self):\n",
    "        return self.counter >= self.patience\n"
   ],
   "id": "e0c5a5cf3e843097",
   "outputs": [],
   "execution_count": 50
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T07:58:56.240621Z",
     "start_time": "2025-03-06T07:58:56.231591Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 训练\n",
    "def training(\n",
    "        model,\n",
    "        train_loader,\n",
    "        val_loader,\n",
    "        epoch,\n",
    "        loss_fct,\n",
    "        optimizer,\n",
    "        save_ckpt_callback=None,\n",
    "        early_stop_callback=None,\n",
    "        eval_step=500,\n",
    "):\n",
    "    record_dict = {\n",
    "        \"train\": [],\n",
    "        \"val\": []\n",
    "    }\n",
    "\n",
    "    global_step = 0\n",
    "    model.train()\n",
    "    with tqdm(total=epoch * len(train_loader)) as pbar:\n",
    "        for epoch_id in range(epoch):\n",
    "            # training\n",
    "            for datas, labels in train_loader:\n",
    "                datas = datas.to(device)\n",
    "                labels = labels.to(device)\n",
    "                # 梯度清空\n",
    "                optimizer.zero_grad()\n",
    "                # 模型前向计算\n",
    "                logits = model(datas)\n",
    "                # 计算损失\n",
    "                loss = loss_fct(logits, labels)\n",
    "                # 梯度回传\n",
    "                loss.backward()\n",
    "                # 调整优化器，包括学习率的变动等\n",
    "                optimizer.step()\n",
    "                preds = logits > 0\n",
    "\n",
    "                acc = accuracy_score(labels.cpu().numpy(), preds.cpu().numpy())\n",
    "                loss = loss.cpu().item()\n",
    "                # record\n",
    "\n",
    "                record_dict[\"train\"].append({\n",
    "                    \"loss\": loss, \"acc\": acc, \"step\": global_step\n",
    "                })\n",
    "\n",
    "                # evaluating\n",
    "                if global_step % eval_step == 0:\n",
    "                    model.eval()\n",
    "                    val_loss, val_acc = evaluating(model, val_loader, loss_fct)\n",
    "                    record_dict[\"val\"].append({\n",
    "                        \"loss\": val_loss, \"acc\": val_acc, \"step\": global_step\n",
    "                    })\n",
    "                    model.train()\n",
    "\n",
    "                    # 1. 保存模型权重 save model checkpoint\n",
    "                    if save_ckpt_callback is not None:\n",
    "                        save_ckpt_callback(global_step, model.state_dict(), metric=val_acc)\n",
    "\n",
    "                    # 2. 早停 Early Stop\n",
    "                    if early_stop_callback is not None:\n",
    "                        early_stop_callback(val_acc)\n",
    "                        if early_stop_callback.early_stop:\n",
    "                            print(f\"Early stop at epoch {epoch_id} / global_step {global_step}\")\n",
    "                            return record_dict\n",
    "\n",
    "                # udate step\n",
    "                global_step += 1\n",
    "                pbar.update(1)\n",
    "                pbar.set_postfix({\"epoch\": epoch_id})\n",
    "\n",
    "    return record_dict"
   ],
   "id": "b960335609e774d",
   "outputs": [],
   "execution_count": 51
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T08:01:47.370568Z",
     "start_time": "2025-03-06T07:58:56.241631Z"
    }
   },
   "cell_type": "code",
   "source": [
    "epoch = 20\n",
    "\n",
    "model = LSTM()\n",
    "\n",
    "# 1. 定义损失函数 采用交叉熵损失 (但是二分类)\n",
    "loss_fct = F.binary_cross_entropy_with_logits\n",
    "# 2. 定义优化器 采用 adam\n",
    "# Optimizers specified in the torch.optim package\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=0.001)\n",
    "\n",
    "# 1. save best\n",
    "if not os.path.exists(\"checkpoints\"):\n",
    "    os.makedirs(\"checkpoints\")\n",
    "save_ckpt_callback = SaveCheckpointsCallback(\"checkpoints/imdb-lstm\", save_step=len(train_dl), save_best_only=True)\n",
    "# 2. early stop\n",
    "early_stop_callback = EarlyStopCallback(patience=10)\n",
    "\n",
    "model = model.to(device)\n",
    "record = training(\n",
    "    model,\n",
    "    train_dl,\n",
    "    test_dl,\n",
    "    epoch,\n",
    "    loss_fct,\n",
    "    optimizer,\n",
    "    save_ckpt_callback=save_ckpt_callback,\n",
    "    early_stop_callback=early_stop_callback,\n",
    "    eval_step=len(train_dl)\n",
    ")"
   ],
   "id": "3b521ca34f24ef89",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "  0%|          | 0/3920 [00:00<?, ?it/s]"
      ],
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "0d5fcda6e84245ffad7067a4da2bc643"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 52
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T08:01:47.512554Z",
     "start_time": "2025-03-06T08:01:47.371073Z"
    }
   },
   "cell_type": "code",
   "source": [
    "#画线要注意的是损失是不一定在零到1之间的\n",
    "def plot_learning_curves(record_dict, sample_step=500):\n",
    "    # build DataFrame\n",
    "    train_df = pd.DataFrame(record_dict[\"train\"]).set_index(\"step\").iloc[::sample_step]\n",
    "    val_df = pd.DataFrame(record_dict[\"val\"]).set_index(\"step\")\n",
    "\n",
    "    # plot\n",
    "    fig_num = len(train_df.columns)\n",
    "    fig, axs = plt.subplots(1, fig_num, figsize=(5 * fig_num, 5))\n",
    "    for idx, item in enumerate(train_df.columns):\n",
    "        axs[idx].plot(train_df.index, train_df[item], label=f\"train_{item}\")\n",
    "        axs[idx].plot(val_df.index, val_df[item], label=f\"val_{item}\")\n",
    "        axs[idx].grid()\n",
    "        axs[idx].legend()\n",
    "        # axs[idx].set_xticks(range(0, train_df.index[-1], 5000))\n",
    "        # axs[idx].set_xticklabels(map(lambda x: f\"{int(x/1000)}k\", range(0, train_df.index[-1], 5000)))\n",
    "        axs[idx].set_xlabel(\"step\")\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "plot_learning_curves(record, sample_step=10)  #横坐标是 steps"
   ],
   "id": "cd12741f252541f7",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 53
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 评估",
   "id": "d9c391348adf1df5"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T08:01:51.198634Z",
     "start_time": "2025-03-06T08:01:47.513559Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# dataload for evaluating\n",
    "\n",
    "# load checkpoints\n",
    "model.load_state_dict(torch.load(\"checkpoints/imdb-lstm/best.ckpt\", map_location=\"cpu\"))\n",
    "\n",
    "model.eval()\n",
    "loss, acc = evaluating(model, test_dl, loss_fct)\n",
    "print(f\"loss:     {loss:.4f}\\naccuracy: {acc:.4f}\")"
   ],
   "id": "a32522d8f3a51386",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss:     0.3841\n",
      "accuracy: 0.8660\n"
     ]
    }
   ],
   "execution_count": 54
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T08:01:51.202012Z",
     "start_time": "2025-03-06T08:01:51.199639Z"
    }
   },
   "cell_type": "code",
   "source": "",
   "id": "e40031c88bde0756",
   "outputs": [],
   "execution_count": 54
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
